/**
 * 中文集合封装 (zh-set.js)
 * 支持 ES6 Set 集合操作 + 链式调用（返回新集合，不修改原始 Set）
 * 中文方法命名 + JSDoc 参数提示
 */

class 集合 {
  /**
   * 构造函数 - 创建集合实例
   * @param {Iterable} [值=[]] 可迭代对象初始化集合
   */
  constructor(值 = []) {
    this._值 = new Set(值);
  }

  /**
   * 获取原始 Set 的副本
   * @returns {Set} 集合数据的副本
   */
  取值() {
    return new Set(this._值);
  }

  /**
   * 打印集合内容到控制台
   * @returns {集合} 返回this以支持链式调用
   */
  打印() {
    console.log(this._值);
    return this;
  }

  /**
   * 添加元素到集合，返回新集合（不修改原集合）
   * @param {...*} 元素 要添加的元素
   * @returns {集合} 新的集合实例
   */
  添加(...元素) {
    const 新集合 = new Set(this._值);
    for (const e of 元素) {
      新集合.add(e);
    }
    return new 集合(新集合);
  }

  /**
   * 从集合删除元素，返回新集合（不修改原集合）
   * @param {*} 元素 要删除的元素
   * @returns {集合} 新的集合实例
   */
  删除(元素) {
    const 新集合 = new Set(this._值);
    新集合.delete(元素);
    return new 集合(新集合);
  }

  /**
   * 判断集合是否包含指定元素
   * @param {*} 元素 要检查的元素
   * @returns {boolean} 是否包含该元素
   */
  包含(元素) {
    return this._值.has(元素);
  }

  /**
   * 返回空集合（不修改原集合）
   * @returns {集合} 空集合实例
   */
  清空() {
    return new 集合();
  }

  /**
   * 获取集合中元素数量
   * @returns {number} 集合的大小
   */
  大小() {
    return this._值.size;
  }

  /**
   * 将集合转换为数组
   * @returns {Array} 包含集合所有元素的数组
   */
  转数组() {
    return [...this._值];
  }

  /**
   * 将集合转换为字符串
   * @returns {string} 转换后的字符串
   */
  转字符串() {
    return Array.from(this._值).toString();
  }

  /**
   * 计算当前集合与其他集合的并集
   * @param {...Set|...集合} 集合项 要计算并集的集合
   * @returns {集合} 并集结果
   */
  并集(...集合项) {
    const 新集合 = new Set(this._值);
    for (const s of 集合项) {
      for (const v of s instanceof 集合 ? s._值 : s) {
        新集合.add(v);
      }
    }
    return new 集合(新集合);
  }

  /**
   * 计算当前集合与其他集合的交集
   * @param {...Set|...集合} 集合项 要计算交集的集合
   * @returns {集合} 交集结果
   */
  交集(...集合项) {
    let 新集合 = new Set(this._值);
    for (const s of 集合项) {
      const 比较集合 = s instanceof 集合 ? s._值 : new Set(s);
      新集合 = new Set([...新集合].filter(x => 比较集合.has(x)));
    }
    return new 集合(新集合);
  }

  /**
   * 计算当前集合与其他集合的差集
   * @param {...Set|...集合} 集合项 要计算差集的集合
   * @returns {集合} 差集结果
   */
  差集(...集合项) {
    let 新集合 = new Set(this._值);
    for (const s of 集合项) {
      const 比较集合 = s instanceof 集合 ? s._值 : new Set(s);
      新集合 = new Set([...新集合].filter(x => !比较集合.has(x)));
    }
    return new 集合(新集合);
  }

  /**
   * 计算当前集合与其他集合的补集
   * @param {...Set|...集合} 集合项 要计算补集的集合
   * @returns {集合} 补集结果
   */
  补集(...集合项) {
    const 并 = this.并集(...集合项);
    const 交 = this.交集(...集合项);
    return 并.差集(交);
  }

  /**
   * 遍历集合中所有元素
   * @param {Function} 回调 遍历回调函数，接收(元素,元素,集合)参数
   * @returns {集合} 返回this以支持链式调用
   */
  遍历(回调) {
    this._值.forEach(回调);
    return this;
  }

  /** 静态方法 */

  /**
   * 静态方法：判断对象是否为Set实例
   * @static
   * @param {*} v 要检查的对象
   * @returns {boolean} 是否为Set实例
   */
  static 是否集合(v) {
    return v instanceof Set;
  }

  /**
   * 静态方法：创建集合
   * @static
   * @param {Iterable} [可迭代=[]] 可迭代对象
   * @returns {集合} 集合实例
   */
  static 创建(可迭代 = []) {
    return new 集合(可迭代);
  }
}

// 规范导出
// 同时支持 ES 模块和 CommonJS 导出
try {
  // 浏览器环境导出
  if (typeof exports === 'undefined') {
    window.集合 = 集合;
  }
} catch (e) {}

// CommonJS 导出

  module.exports = {
    集合,
    default: 集合
  };
  module.exports.集合 = 集合;


// ES 模块导出
// export { 集合 };
// export default 集合;
